package com.hjx.windowtool.photo2video;

import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.nio.Buffer;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;

import javax.imageio.ImageIO;

import org.bytedeco.javacpp.avcodec;
import org.bytedeco.javacpp.opencv_core;
import org.bytedeco.javacpp.opencv_core.IplImage;
import org.bytedeco.javacpp.opencv_imgcodecs;
import org.bytedeco.javacv.FFmpegFrameGrabber;
import org.bytedeco.javacv.FFmpegFrameRecorder;
import org.bytedeco.javacv.Frame;
import org.bytedeco.javacv.Java2DFrameConverter;
import org.bytedeco.javacv.OpenCVFrameConverter;
import org.bytedeco.javacv.OpenCVFrameConverter.ToIplImage;

public class JavacvUtils {
	public interface JavacvCallback {
		public int msg(int totalFrames, int runSize, String msg);
		public default void error(Throwable e) {}
	}

	public static JavacvCallback call = null;
	public static AtomicInteger pSize=new AtomicInteger(0);
	public static long time=0;

	private static final double FRAME_RATE = 23.94;
	
	static {
		System.setProperty("org.bytedeco.javacpp.maxphysicalbytes", "5G");
	}

	public static void main(String[] args) throws Exception {
		// IplImage cvLoadImage = opencv_imgcodecs.cvLoadImage("123.png");
		// System.out.println(cvLoadImage);

		// extractVoice(System.getProperty("user.dir") + File.separator + "S05E12.mp4");

		// recorderImages("D:\\git\\mytest\\mytest\\S05E12",System.getProperty("user.dir")
		// + File.separator + "S05E12.mp4", 0);

//		extractImages(System.getProperty("user.dir") + File.separator + "s202.rmvb",
//				System.getProperty("user.dir") + File.separator + "123");
		extractImages("G:\\BaiduYunDownload\\111\\lance\\sp.mp4", "G:\\BaiduYunDownload\\111\\lance\\sp");
	}

	/**
	 * 将视频解析成一帧帧图片保存起来
	 * 
	 * @param moviePath
	 *            视频路径
	 * @param toPath
	 *            提取图片保存文件夹
	 * @throws Exception
	 */
	public static void extractImages(final String moviePath, final String toPath) throws Exception {
		pSize.set(0);
		time=System.currentTimeMillis();
		FFmpegFrameGrabber ff = new FFmpegFrameGrabber(moviePath);
		ff.start();
		final int lengthInFrames = ff.getLengthInFrames();
		ff.close();
		int size=lengthInFrames/5;
		for (int i = 0; i < lengthInFrames; i+=size) {
			extractImages(moviePath, toPath, i, size);
		}
//		ExecutorService service = Executors.newFixedThreadPool(10);
//		long currentTimeMillis = System.currentTimeMillis();
//		 OpenCVFrameConverter.ToIplImage toIplImage = new
//		 OpenCVFrameConverter.ToIplImage();
////		OpenCVFrameConverter.ToMat toMat = new OpenCVFrameConverter.ToMat();
//		Java2DFrameConverter java2dConverter=new Java2DFrameConverter();
//		for (int i = 0; i < lengthInFrames; i++) {
//			System.out.println(lengthInFrames + "===" + pSize.get());
//			final Frame frame = ff.grabImage();
//			if (frame == null) {
//				service.shutdown();
//				break;
//			}
//			final String filename = toPath + "\\" + i + ".jpg";
//			// IplImage convert = toIplImage.convert(frame);
//			// opencv_imgcodecs.cvSaveImage(filename, convert.asCvMat()); //??? opencv 3.4.1
//			// 会系统崩溃退出
////			opencv_imgcodecs.imwrite(filename, toMat.convert(frame));
//			
//			final BufferedImage image = java2dConverter.convert(frame);
//			Runnable runnable = new Runnable() {
//				public void run() {
//					try {
//						ImageIO.write(image, "jpeg", new FileOutputStream(filename));
//						System.out.println("保存图片完成:" + filename);
//						 int addAndGet = pSize.addAndGet(1);
//						if (call != null) {
//							call.msg(lengthInFrames, addAndGet, "保存图片完成:" + filename);
//						}
//					} catch (IOException e) {
//						if (call != null) {
//							call.error(e);
//						}
//					}finally {
//						if (pSize.get()==lengthInFrames-1) {
//							service.shutdown();
//							System.out.println("花费时间："+(System.currentTimeMillis()-currentTimeMillis));
//						}
//					}
//				}
//			};
//			service.submit(runnable);
//		}
//		ff.close();

	}
	public static void extractMovie(final String moviePath,List<int[]> parts) throws Exception {


		FFmpegFrameGrabber ff = new FFmpegFrameGrabber(moviePath);
		ff.start();
		int lengthInFrames = ff.getLengthInFrames();
		System.out.println(lengthInFrames);
		System.out.println(ff.getFrameRate());
		double frameRate = new BigDecimal(ff.getFrameRate()-0.02).setScale(2, RoundingMode.HALF_UP).doubleValue();
		System.out.println(frameRate);

		File dir = new File(moviePath.substring(0, moviePath.lastIndexOf("."))+"_edit.mp4");
		if (!dir.exists()||dir.isDirectory()) {
			dir.createNewFile();
		}
		/**
		 * FFmpegFrameRecorder(String filename, int imageWidth, int imageHeight, int
		 * audioChannels) fileName可以是本地文件（会自动创建），也可以是RTMP路径（发布到流媒体服务器） imageWidth =
		 * width （为捕获器设置宽） imageHeight = height （为捕获器设置高） audioChannels =
		 * 2（立体声）；1（单声道）；0（无音频）
		 */
		FFmpegFrameRecorder ffr = new FFmpegFrameRecorder(dir.getAbsolutePath(), ff.getImageWidth(),
				ff.getImageHeight(), 2);
		ffr.setInterleaved(true);

		/**
		 * 该参数用于降低延迟 参考FFMPEG官方文档：https://trac.ffmpeg.org/wiki/StreamingGuide
		 * 官方原文参考：ffmpeg -f dshow -i video="Virtual-Camera" -vcodec libx264 -tune
		 * zerolatency -b 900k -f mpegts udp://10.1.0.102:1234
		 */

		ffr.setVideoOption("tune", "zerolatency");
		/**
		 * 权衡quality(视频质量)和encode speed(编码速度) values(值)： ultrafast(终极快),superfast(超级快),
		 * veryfast(非常快), faster(很快), fast(快), medium(中等), slow(慢), slower(很慢),
		 * veryslow(非常慢)
		 * ultrafast(终极快)提供最少的压缩（低编码器CPU）和最大的视频流大小；而veryslow(非常慢)提供最佳的压缩（高编码器CPU）的同时降低视频流的大小
		 * 参考：https://trac.ffmpeg.org/wiki/Encode/H.264 官方原文参考：-preset ultrafast as the
		 * name implies provides for the fastest possible encoding. If some tradeoff
		 * between quality and encode speed, go for the speed. This might be needed if
		 * you are going to be transcoding multiple streams on one machine.
		 */
		ffr.setVideoOption("preset", "ultrafast");
		/**
		 * 参考转流命令: ffmpeg -i'udp://localhost:5000?fifo_size=1000000&overrun_nonfatal=1'
		 * -crf 30 -preset ultrafast -acodec aac -strict experimental -ar 44100 -ac
		 * 2-b:a 96k -vcodec libx264 -r 25 -b:v 500k -f flv 'rtmp://<wowza
		 * serverIP>/live/cam0' -crf 30
		 * -设置内容速率因子,这是一个x264的动态比特率参数，它能够在复杂场景下(使用不同比特率，即可变比特率)保持视频质量；
		 * 可以设置更低的质量(quality)和比特率(bit rate),参考Encode/H.264 -preset ultrafast
		 * -参考上面preset参数，与视频压缩率(视频大小)和速度有关,需要根据情况平衡两大点：压缩率(视频大小)，编/解码速度 -acodec aac
		 * -设置音频编/解码器 (内部AAC编码) -strict experimental -允许使用一些实验的编解码器(比如上面的内部AAC属于实验编解码器)
		 * -ar 44100 设置音频采样率(audio sample rate) -ac 2 指定双通道音频(即立体声) -b:a 96k 设置音频比特率(bit
		 * rate) -vcodec libx264 设置视频编解码器(codec) -r 25 -设置帧率(frame rate) -b:v 500k
		 * -设置视频比特率(bit rate),比特率越高视频越清晰,视频体积也会变大,需要根据实际选择合理范围 -f flv
		 * -提供输出流封装格式(rtmp协议只支持flv封装格式) 'rtmp://<FMS server IP>/live/cam0'-流媒体服务器地址
		 */
		ffr.setVideoOption("crf", "0");
		// 2000 kb/s, 720P视频的合理比特率范围
		ffr.setVideoBitrate(ff.getVideoBitrate()<=0?getDefaultVideoBitrate(ff.getImageHeight()):ff.getVideoBitrate());
		// h264编/解码器
		ffr.setVideoCodec(avcodec.AV_CODEC_ID_MPEG4);
		// 封装格式flv
		ffr.setFormat("mp4");
		// 视频帧率(保证视频质量的情况下最低25，低于25会出现闪屏)
		ffr.setFrameRate(frameRate);
		// 关键帧间隔，一般与帧率相同或者是视频帧率的两倍
		// ffr.setGopSize((int) (FRAME_RATE * 2));
		// 不可变(固定)音频比特率
		ffr.setAudioOption("crf", "0");
		// 最高质量
		ffr.setAudioQuality(0);
		// 音频比特率
		ffr.setAudioBitrate(ff.getAudioBitrate()<=0?192000:ff.getAudioBitrate());
		// 音频采样率
		ffr.setSampleRate(ff.getSampleRate()<=0?44100:ff.getSampleRate());
		// 双通道(立体声)
		ffr.setAudioChannels(2);
		// 音频编/解码器
		ffr.setAudioCodec(avcodec.AV_CODEC_ID_AAC);
		ffr.start();

		for (int i = 0; i < parts.size(); i++) {
			int[] part = parts.get(i);
			ff.setFrameNumber(part[0]);
			System.out.println(part[0]+"=="+part[1]);
			for (; ff.getFrameNumber() < part[1];) {
				Frame grab = ff.grab();
				Frame convert = grab;
				ffr.record(convert);
				int addAndGet = pSize.addAndGet(1);
				String msg = lengthInFrames + "=" + ff.getFrameNumber() + "==";
				System.out.println(msg);
				if (call != null) {
					call.msg(lengthInFrames, addAndGet, msg);
				}
			}
		}
		ffr.close();
		ff.close();
	
	}
	public static void extractImages(final String moviePath, final String toPath, int start, int length)
			throws Exception {
		Runnable runnable = new Runnable() {
			public void run() {
				try {
					FFmpegFrameGrabber ff = new FFmpegFrameGrabber(moviePath);
					ff.start();
					ff.setFrameNumber(start);
					int lengthInFrames = ff.getLengthInFrames();
					// OpenCVFrameConverter.ToIplImage toIplImage = new
					// OpenCVFrameConverter.ToIplImage();
					OpenCVFrameConverter.ToMat toMat = new OpenCVFrameConverter.ToMat();
					for (int i = start; i < start + length; i++) {
						System.out.println(lengthInFrames + "===" + pSize.get());
						final Frame frame = ff.grabImage();
						if (frame == null) {
							break;
						}
						String filename = toPath + "\\" + i + ".jpg";
						// IplImage convert = toIplImage.convert(frame);
						// opencv_imgcodecs.cvSaveImage(filename, convert.asCvMat()); //??? opencv 3.4.1
						// 会系统崩溃退出

						opencv_imgcodecs.imwrite(filename, toMat.convert(frame));
//						System.out.println("保存图片完成:" + filename);
						int addAndGet = pSize.addAndGet(1);
						if (call != null) {
							call.msg(lengthInFrames, addAndGet, "保存图片完成:" + filename);
						}
					}
					if (pSize.get()>=lengthInFrames-5) {
						String x = "花费时间："+(System.currentTimeMillis()-time);
						System.out.println(x);
						if (call != null) {
							call.msg(lengthInFrames, pSize.get(), x);
						}
					}
					ff.close();
				} catch (Throwable e) {
					e.printStackTrace();
					if (call != null) {
						call.error(e);
					}
				}
			}
		};
		new Thread(runnable).start();
	}

	public static void extractVoice(String moviePath) throws Exception {
		FFmpegFrameGrabber ff = new FFmpegFrameGrabber(moviePath);
		ff.start();

		FFmpegFrameRecorder ffr = new FFmpegFrameRecorder("2.mp3", 2);
		ffr.setInterleaved(true);

		/**
		 * 该参数用于降低延迟 参考FFMPEG官方文档：https://trac.ffmpeg.org/wiki/StreamingGuide
		 * 官方原文参考：ffmpeg -f dshow -i video="Virtual-Camera" -vcodec libx264 -tune
		 * zerolatency -b 900k -f mpegts udp://10.1.0.102:1234
		 */

		ffr.setVideoOption("tune", "zerolatency");
		/**
		 * 权衡quality(视频质量)和encode speed(编码速度) values(值)： ultrafast(终极快),superfast(超级快),
		 * veryfast(非常快), faster(很快), fast(快), medium(中等), slow(慢), slower(很慢),
		 * veryslow(非常慢)
		 * ultrafast(终极快)提供最少的压缩（低编码器CPU）和最大的视频流大小；而veryslow(非常慢)提供最佳的压缩（高编码器CPU）的同时降低视频流的大小
		 * 参考：https://trac.ffmpeg.org/wiki/Encode/H.264 官方原文参考：-preset ultrafast as the
		 * name implies provides for the fastest possible encoding. If some tradeoff
		 * between quality and encode speed, go for the speed. This might be needed if
		 * you are going to be transcoding multiple streams on one machine.
		 */
		ffr.setVideoOption("preset", "quality");
		/**
		 * 参考转流命令: ffmpeg -i'udp://localhost:5000?fifo_size=1000000&overrun_nonfatal=1'
		 * -crf 30 -preset ultrafast -acodec aac -strict experimental -ar 44100 -ac
		 * 2-b:a 96k -vcodec libx264 -r 25 -b:v 500k -f flv 'rtmp://<wowza
		 * serverIP>/live/cam0' -crf 30
		 * -设置内容速率因子,这是一个x264的动态比特率参数，它能够在复杂场景下(使用不同比特率，即可变比特率)保持视频质量；
		 * 可以设置更低的质量(quality)和比特率(bit rate),参考Encode/H.264 -preset ultrafast
		 * -参考上面preset参数，与视频压缩率(视频大小)和速度有关,需要根据情况平衡两大点：压缩率(视频大小)，编/解码速度 -acodec aac
		 * -设置音频编/解码器 (内部AAC编码) -strict experimental -允许使用一些实验的编解码器(比如上面的内部AAC属于实验编解码器)
		 * -ar 44100 设置音频采样率(audio sample rate) -ac 2 指定双通道音频(即立体声) -b:a 96k 设置音频比特率(bit
		 * rate) -vcodec libx264 设置视频编解码器(codec) -r 25 -设置帧率(frame rate) -b:v 500k
		 * -设置视频比特率(bit rate),比特率越高视频越清晰,视频体积也会变大,需要根据实际选择合理范围 -f flv
		 * -提供输出流封装格式(rtmp协议只支持flv封装格式) 'rtmp://<FMS server IP>/live/cam0'-流媒体服务器地址
		 */
		ffr.setVideoOption("crf", "0");
		// 2000 kb/s, 720P视频的合理比特率范围
		ffr.setVideoBitrate(ff.getVideoBitrate());
		// h264编/解码器
		ffr.setVideoCodec(avcodec.AV_CODEC_ID_MPEG4);
		// 封装格式flv
		ffr.setFormat("mp4");
		// 视频帧率(保证视频质量的情况下最低25，低于25会出现闪屏)
		ffr.setFrameRate(ff.getFrameRate());
		// 关键帧间隔，一般与帧率相同或者是视频帧率的两倍
		// ffr.setGopSize((int) (FRAME_RATE * 2));
		// 不可变(固定)音频比特率
		ffr.setAudioOption("crf", "0");
		// 最高质量
		ffr.setAudioQuality(0);
		// 音频比特率
		ffr.setAudioBitrate(ff.getAudioBitrate());
		// 音频采样率
		ffr.setSampleRate(ff.getSampleRate());
		// 双通道(立体声)
		ffr.setAudioChannels(ff.getAudioChannels());
		// 音频编/解码器
		ffr.setAudioCodec(avcodec.AV_CODEC_ID_AAC);
		ffr.start();
		Frame grabSamples = null;
		int lengthInFrames = ff.getLengthInFrames();
		int total = 0;
		for (int i = 0;; i++) {
			grabSamples = ff.grabSamples();
			if (grabSamples == null) {
				break;
			}
			ffr.recordSamples(grabSamples.samples);
			System.out.println(lengthInFrames + "=" + i + "==" + grabSamples.samples);
			if (call != null) {
				call.msg(lengthInFrames, i, lengthInFrames + "=" + i + "==" + grabSamples.samples);
			}
		}
		System.out.println(total);
		ffr.close();
		ff.close();
	}

	/**
	 * @throws Exception
	 */
	public static void recorderImages(String dirPath, String oldMov, double frameRate) throws Exception {

		FFmpegFrameGrabber ff = new FFmpegFrameGrabber(oldMov);
		ff.start();
		int lengthInFrames = ff.getLengthInFrames();
		System.out.println(lengthInFrames);
		System.out.println(ff.getFrameRate());
		if (frameRate == 0) {
			frameRate = new BigDecimal(ff.getFrameRate() - 0.04).setScale(2, RoundingMode.HALF_UP).doubleValue();
		}
		System.out.println(frameRate);

		File dir = new File(dirPath);
		String filename = dir.getAbsolutePath() + "\\" + 0 + ".jpg";
		IplImage cvLoadImage = opencv_imgcodecs.cvLoadImage(filename);
		ToIplImage toIplImage = new ToIplImage();
		/**
		 * FFmpegFrameRecorder(String filename, int imageWidth, int imageHeight, int
		 * audioChannels) fileName可以是本地文件（会自动创建），也可以是RTMP路径（发布到流媒体服务器） imageWidth =
		 * width （为捕获器设置宽） imageHeight = height （为捕获器设置高） audioChannels =
		 * 2（立体声）；1（单声道）；0（无音频）
		 */
		FFmpegFrameRecorder ffr = new FFmpegFrameRecorder(dirPath + "_edit.mp4", ff.getImageWidth(),
				ff.getImageHeight(), 2);
		ffr.setInterleaved(true);

		/**
		 * 该参数用于降低延迟 参考FFMPEG官方文档：https://trac.ffmpeg.org/wiki/StreamingGuide
		 * 官方原文参考：ffmpeg -f dshow -i video="Virtual-Camera" -vcodec libx264 -tune
		 * zerolatency -b 900k -f mpegts udp://10.1.0.102:1234
		 */

		ffr.setVideoOption("tune", "zerolatency");
		/**
		 * 权衡quality(视频质量)和encode speed(编码速度) values(值)： ultrafast(终极快),superfast(超级快),
		 * veryfast(非常快), faster(很快), fast(快), medium(中等), slow(慢), slower(很慢),
		 * veryslow(非常慢)
		 * ultrafast(终极快)提供最少的压缩（低编码器CPU）和最大的视频流大小；而veryslow(非常慢)提供最佳的压缩（高编码器CPU）的同时降低视频流的大小
		 * 参考：https://trac.ffmpeg.org/wiki/Encode/H.264 官方原文参考：-preset ultrafast as the
		 * name implies provides for the fastest possible encoding. If some tradeoff
		 * between quality and encode speed, go for the speed. This might be needed if
		 * you are going to be transcoding multiple streams on one machine.
		 */
		ffr.setVideoOption("preset", "ultrafast");
		/**
		 * 参考转流命令: ffmpeg -i'udp://localhost:5000?fifo_size=1000000&overrun_nonfatal=1'
		 * -crf 30 -preset ultrafast -acodec aac -strict experimental -ar 44100 -ac
		 * 2-b:a 96k -vcodec libx264 -r 25 -b:v 500k -f flv 'rtmp://<wowza
		 * serverIP>/live/cam0' -crf 30
		 * -设置内容速率因子,这是一个x264的动态比特率参数，它能够在复杂场景下(使用不同比特率，即可变比特率)保持视频质量；
		 * 可以设置更低的质量(quality)和比特率(bit rate),参考Encode/H.264 -preset ultrafast
		 * -参考上面preset参数，与视频压缩率(视频大小)和速度有关,需要根据情况平衡两大点：压缩率(视频大小)，编/解码速度 -acodec aac
		 * -设置音频编/解码器 (内部AAC编码) -strict experimental -允许使用一些实验的编解码器(比如上面的内部AAC属于实验编解码器)
		 * -ar 44100 设置音频采样率(audio sample rate) -ac 2 指定双通道音频(即立体声) -b:a 96k 设置音频比特率(bit
		 * rate) -vcodec libx264 设置视频编解码器(codec) -r 25 -设置帧率(frame rate) -b:v 500k
		 * -设置视频比特率(bit rate),比特率越高视频越清晰,视频体积也会变大,需要根据实际选择合理范围 -f flv
		 * -提供输出流封装格式(rtmp协议只支持flv封装格式) 'rtmp://<FMS server IP>/live/cam0'-流媒体服务器地址
		 */
		ffr.setVideoOption("crf", "0");
		// 2000 kb/s, 720P视频的合理比特率范围
		ffr.setVideoBitrate(ff.getVideoBitrate()<=0?getDefaultVideoBitrate(ff.getImageHeight()):ff.getVideoBitrate());
		// h264编/解码器
		ffr.setVideoCodec(avcodec.AV_CODEC_ID_MPEG4);
		// 封装格式flv
		ffr.setFormat("mp4");
		// 视频帧率(保证视频质量的情况下最低25，低于25会出现闪屏)
		ffr.setFrameRate(frameRate);
		// 关键帧间隔，一般与帧率相同或者是视频帧率的两倍
		// ffr.setGopSize((int) (FRAME_RATE * 2));
		// 不可变(固定)音频比特率
		ffr.setAudioOption("crf", "0");
		// 最高质量
		ffr.setAudioQuality(0);
		// 音频比特率
		ffr.setAudioBitrate(ff.getAudioBitrate()<=0?192000:ff.getAudioBitrate());
		// 音频采样率
		ffr.setSampleRate(ff.getSampleRate()<=0?44100:ff.getSampleRate());
		// 双通道(立体声)
		ffr.setAudioChannels(2);
		// 音频编/解码器
		ffr.setAudioCodec(avcodec.AV_CODEC_ID_AAC);
		ffr.start();

		ffr.setFrameNumber(0);
		if (cvLoadImage!=null) {
			ffr.record(toIplImage.convert(cvLoadImage));
			opencv_core.cvRelease(cvLoadImage);
		}
		for (int i = 1; i < lengthInFrames; i++) {
			Frame grab = ff.grabImage();
			// 创建一个 timestamp用来写入帧中
			filename = dir.getAbsolutePath() + "\\" + i + ".jpg";
			cvLoadImage = opencv_imgcodecs.cvLoadImage(filename);
			ffr.setFrameNumber(i);
			// ffr.setTimestamp(videoTS);
			Frame convert = grab;
			if (cvLoadImage != null) {
				convert = toIplImage.convert(cvLoadImage);
			}
			// convert.sampleRate=grab.sampleRate;
			// convert.samples=grab.samples;
			// convert.audioChannels=grab.audioChannels;
			ffr.record(convert);

			if (cvLoadImage != null) {
				opencv_core.cvRelease(cvLoadImage);
			}
			System.out.println(filename);
			if (call != null) {
				call.msg(lengthInFrames, i, lengthInFrames + "=" + i + "==" + filename);
			}
		}
		ff.setFrameNumber(0);
		for (int i = 0;; i++) {
			Frame grabSamples = ff.grabSamples();
			if (grabSamples == null) {
				break;
			}
			ffr.record(grabSamples);
			System.out.println(i + "=grabSamples=" + grabSamples.samples);
			if (call != null) {
				call.msg(lengthInFrames, i, "编码声音=" + i + "");
			}
		}
		ffr.close();
		ff.close();
	}

	public static int getDefaultVideoBitrate(int height) {
		if (height>=1080) {
			return 8192000;
		}
		return 2000000;
	}

	public static long[] getMovieFrameAndTimeLength(String videoPath) {
		long[] lengthInFrames=null;
		try(FFmpegFrameGrabber ff = new FFmpegFrameGrabber(videoPath)) {
			ff.start();
			int l = ff.getLengthInFrames();
			long lengthInTime = ff.getLengthInTime();
			lengthInFrames=new long[] {l,lengthInTime};
		} catch (Exception e) {
			
		}
		return lengthInFrames;
	}
}
